package com.quanyan.orderpay.task;

import com.github.ltsopensource.core.domain.Job;
import com.github.ltsopensource.jobclient.JobClient;
import com.github.ltsopensource.jobclient.domain.Response;
import com.quanyan.orderpay.scheduler.OrderPayTask;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author xian-guo
 */
public class TimerTaskJob {

    private Logger logger = LoggerFactory.getLogger(TimerTaskJob.class);

    @Autowired
    private JobClient jobClient;

    public void executeTask(){
        //微信退款查询
        Job refundQuery= new Job();
        refundQuery.setTaskId("task_orderPay_refund_query");//每个任务必须指定唯一
        refundQuery.setParam("type",OrderPayTask.REFUND_STATUS_QUERY);//执行多个任务，传递参数
        refundQuery.setTaskTrackerNodeGroup(OrderPayTask.ORDER_GROUP);//每个模块指定不同的名称，但同一个模块不同任务必须相同
        refundQuery.setNeedFeedback(true);
        refundQuery.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        refundQuery.setRepeatCount(-1);             // 无限循环
        refundQuery.setRepeatInterval(5 * 1000L);  //5s执行一次
        //job.setCronExpression("0 0 0 * * ?");
        jobClient.submitJob(refundQuery);

        //订单关闭
        Job orderClose = new Job();
        orderClose.setTaskId("task_orderPay_close_order");//每个任务必须指定唯一
        orderClose.setParam("type",OrderPayTask.ORDER_CLOSE);//执行多个任务，传递参数
        orderClose.setTaskTrackerNodeGroup(OrderPayTask.ORDER_GROUP);//每个模块指定不同的名称，但同一个模块不同任务必须相同
        orderClose.setNeedFeedback(true);
        orderClose.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        orderClose.setRepeatCount(-1);             // 无限循环
        orderClose.setRepeatInterval(5 * 1000L);  //5s执行一次
        //job.setCronExpression("0 0 0 * * ?");
        Response response = jobClient.submitJob(orderClose);

        //订单消息重发
        Job orderMq = new Job();
        orderMq.setTaskId("task_orderPay_ordermq");//每个任务必须指定唯一
        orderMq.setParam("type",OrderPayTask.ORDER_MQ);//执行多个任务，传递参数
        orderMq.setTaskTrackerNodeGroup(OrderPayTask.ORDER_GROUP);//每个模块指定不同的名称，但同一个模块不同任务必须相同
        orderMq.setNeedFeedback(true);
        orderMq.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        orderMq.setRepeatCount(-1);             // 无限循环
        orderMq.setRepeatInterval(5 * 1000L);  //5s执行一次
        //job.setCronExpression("0 0 0 * * ?");
        jobClient.submitJob(orderMq);



        //提现重置
        Job withdrawReset = new Job();
        withdrawReset.setTaskId("task_orderPay_withdraw_reset");//每个任务必须指定唯一
        withdrawReset.setParam("type",OrderPayTask.WITHDRAW_RESET);//执行多个任务，传递参数
        withdrawReset.setTaskTrackerNodeGroup(OrderPayTask.ORDER_GROUP);//每个模块指定不同的名称，但同一个模块不同任务必须相同
        withdrawReset.setNeedFeedback(true);
        withdrawReset.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        withdrawReset.setRepeatCount(-1);             // 无限循环
        withdrawReset.setRepeatInterval(5 * 1000L);  //5s执行一次
        //job.setCronExpression("0 0 0 * * ?");
        jobClient.submitJob(withdrawReset);


        // h5 ACCESS_TOKEN定时刷新
        Job accessTokenJob = new Job();
        accessTokenJob.setTaskId("task_orderPay_weichat_access_token");//每个任务必须指定唯一
        accessTokenJob.setParam("type",OrderPayTask.WEICHAT_ACCESS_TOKEN);//执行多个任务，传递参数
        accessTokenJob.setTaskTrackerNodeGroup(OrderPayTask.ORDER_GROUP);//每个模块指定不同的名称，但同一个模块不同任务必须相同
        accessTokenJob.setNeedFeedback(true);
        accessTokenJob.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        accessTokenJob.setRepeatCount(-1);             // 无限循环
        accessTokenJob.setRepeatInterval(3000 * 1000L);  //3000s执行一次
        //job.setCronExpression("0 0 0 * * ?");
        jobClient.submitJob(accessTokenJob);

        //订单查询
        Job orderQuery = new Job();
        orderQuery.setTaskId("task_orderPay_orderQuery");//每个任务必须指定唯一
        orderQuery.setParam("type",OrderPayTask.ORDER_QUERY);//执行多个任务，传递参数
        orderQuery.setTaskTrackerNodeGroup(OrderPayTask.ORDER_GROUP);//每个模块指定不同的名称，但同一个模块不同任务必须相同
        orderQuery.setNeedFeedback(true);
        orderQuery.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        orderQuery.setRepeatCount(-1);             // 无限循环
        orderQuery.setRepeatInterval(3 * 1000L);  //3s执行一次
        //job.setCronExpression("0 0 0 * * ?");
        jobClient.submitJob(orderQuery);


        //订单消息重发
        Job callBackScanPay = new Job();
        orderMq.setTaskId("task_orderPay_callBackScanPay");//每个任务必须指定唯一
        orderMq.setParam("type",OrderPayTask.CALL_BACK_SCAN_PAY);//执行多个任务，传递参数
        orderMq.setTaskTrackerNodeGroup(OrderPayTask.ORDER_GROUP);//每个模块指定不同的名称，但同一个模块不同任务必须相同
        orderMq.setNeedFeedback(true);
        orderMq.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        orderMq.setRepeatCount(-1);             // 无限循环
        orderMq.setRepeatInterval(3 * 1000L);  //5s执行一次
        //job.setCronExpression("0 0 0 * * ?");
        jobClient.submitJob(orderMq);

        //扫码修复数据
        Job scanPay = new Job();
        scanPay.setTaskId("task_orderPay_scan_pay");//每个任务必须指定唯一
        scanPay.setParam("type",OrderPayTask.SCAN_PAY);//执行多个任务，传递参数
        scanPay.setTaskTrackerNodeGroup(OrderPayTask.ORDER_GROUP);//每个模块指定不同的名称，但同一个模块不同任务必须相同
        scanPay.setNeedFeedback(true);
        scanPay.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        scanPay.setRepeatCount(-1);             // 无限循环
        scanPay.setRepeatInterval(5 * 1000L);  //5s执行一次
        //job.setCronExpression("0 0 0 * * ?");
        jobClient.submitJob(scanPay);



        //每天下载第三方支付流水供财务对账
        Job accountWaterDownload = new Job();
        accountWaterDownload.setTaskId("task_orderPay_account_water_download");
        accountWaterDownload.setParam("type", OrderPayTask.ACCOUNT_WATER_DOWNLOAD);
        accountWaterDownload.setTaskTrackerNodeGroup(OrderPayTask.ORDER_GROUP);
        accountWaterDownload.setNeedFeedback(true);
        accountWaterDownload.setReplaceOnExist(true);

        accountWaterDownload.setCronExpression("0 0 10  * * ?");//每天10点执行下载对账单
        Response awdSubmitRsp = jobClient.submitJob(accountWaterDownload);
        logger.info("下载对账单任务提交结果：" + awdSubmitRsp);
    }

}
